package com.ftwj.demo.base.common;

import java.util.List;
import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;

import com.ftwj.demo.base.annotation.Logic;
import com.ftwj.demo.base.annotation.Primarykey;
import com.ftwj.demo.base.common.inter.ServiceInterface;
import com.ftwj.demo.base.util.PageInfoBean;
import com.ftwj.demo.base.wrapper.ConditionWrapper;
import com.ftwj.demo.base.wrapper.QueryWrapper;
import com.ftwj.demo.base.wrapper.UpdateWrapper;

public abstract class BaseService<T,K> implements ServiceInterface<T,K>{
	
	@Autowired
	private BaseDao<T, K> dao;
	
	/**
	 * 	通用插入，自增列需要添加 {@link Primarykey} 注解
	 *
	 * @param t 对象
	 * @param ignore 是否忽略 null值
	 * @return 操作的行数
	 */
	@Override
	public int add(T t) {
		return dao.insert(t);
	}
	
	/**
	 * 	通用插入，自增列需要添加 {@link Primarykey} 注解
	 *
	 * @param t 对象
	 * @return 操作的行数
	 */
	@Override
	public int add(T t, Boolean ignore) {
		return dao.insert(t, ignore);
	}
	
	/**
	 * 	通用插入，自增列需要添加 {@link Primarykey} 注解
	 *	新增一条记录，并且返回数据的主键
	 *
	 * @param t 对象
	 * @return 操作的行数
	 */
	@Override
	public int addAndGetId(T t) {
		return dao.insertAndGetId(t, true);
	}
	
	/**
	 * 	通用插入，自增列需要添加 {@link Primarykey} 注解
	 *	新增一条记录，并且返回数据的主键
	 *
	 * @param t 对象
	 * @param ignore 是否忽略 null值
	 * @return 操作的行数
	 */
	@Override
	public int addAndGetId(T t, Boolean ignore) {
		return dao.insertAndGetId(t, ignore);
	}
	
	/**
	 * 	通用根据主键物理删除
	 *
	 * @param primarykey 主键
	 * @return 影响行数
	 */
	@Override
	public int delById(K primarykey) {
		return dao.delete(primarykey);
	}
	
	/**
	 * 	通用根据主键物理批量删除
	 *
	 * @param keys 主键列表
	 * @return 影响行数
	 */
	@Override
	public int delByIds(List<K> keys) {
		return dao.delete(keys);
	}
	
	/**
	 * 	通用根据对象物理删除
	 *
	 * @param t 删除条件
	 * @return 影响行数
	 */
	@Override
	public int delByExample(T t) {
		return dao.deleteByExample(t);
	}
	
	/**
	 * 	通用根据特殊条件物理删除{@link ConditionWrapper}
	 *
	 * @param wrapper 条件构造器
	 * @return 影响行数
	 */
	@Override
	public int delByConditions(ConditionWrapper wrapper) {
		return dao.deleteByConditions(wrapper);
	}
	
	/**
	 * 	通用根据主键逻辑删除，列需要添加 {@link Logic} 注解
	 *
	 * @param primarykey 主键
	 * @return 影响行数
	 */
	@Override
	public int remo(K primarykey) {
		return dao.remove(primarykey);
	}
	
	/**
	 * 	通用根据主键逻辑删除，列需要添加 {@link Logic} 注解
	 *
	 * @param keys 主键列表
	 * @return 影响行数
	 */
	@Override
	public int remoByIds(List<K> keys) {
		return dao.remove(keys);
	}
	
	/**
	 * 	通用根据对象逻辑删除
	 *
	 * @param t 删除条件
	 * @return 影响行数
	 */
	@Override
	public int remoByExample(T t) {
		return dao.removeByExample(t);
	}
	
	/**
	 * 	通用根据主键更新，自增列需要添加 {@link Primarykey} 注解
	 *
	 * @param t  对象
	 * @return 操作的行数
	 */
	@Override
	public int save(T t) {
		return dao.update(t);
	}
	
	/**
	 * 	通用根据主键更新，自增列需要添加 {@link Primarykey} 注解
	 *
	 * @param t  对象
	 * @param ignore 是否忽略 null 值
	 * @return 操作的行数
	 */
	@Override
	public int save(T t, Boolean ignore) {
		return dao.update(t, ignore);
	}
	
	/**
	 * 	通用根据主键更新，自增列需要添加 {@link Primarykey} 注解
	 *
	 * @param t  对象
	 * @param fieldList 更新条件(T中的字段名列表)
	 * @param ignore 是否忽略 null 值
	 * @return 操作的行数
	 */
	@Override
	public int saveByExample(T t, List<String> fieldList, Boolean ignore) {
		return dao.updateByExample(t, fieldList, ignore);
	}
	
	/**
	 * 	通用根据主键查询单条记录
	 *
	 * @param primarykey 主键
	 * @return 单条记录BEAN
	 */
	@Override
	public T find(K primarykey) {
		return dao.query(primarykey);
	}
	
	/**
	 * 	通用根据主键查询单条记录
	 *
	 * @param primarykey 主键
	 * @return 单条记录MAP
	 */
	@Override
	public Map<String,Object> findMap(K primarykey) {
		return dao.queryMap(primarykey);
	}
	
	/**
	 * 	通用根据主键查询单条记录 （联合主键）
	 *
	 * @param primarykey 主键
	 * @return 单条记录
	 */
	@Override
	public T findByUniteId(Object... primarykey) {
		return dao.queryByUniteId(primarykey);
	}
	
	/**
	 * 	根据对象查询
	 *
	 * @param t 查询条件
	 * @return 对象列表
	 */
	@Override
	public List<T> findListByExample(T t) {
		return dao.queryListByExample(t);
	}
	
	/**
	 * 	根据对象查询
	 *
	 * @param t 查询条件
	 * @return 对象列表
	 */
	@Override
	public List<Map<String, Object>> findListMapByExample(T t) {
		return dao.queryListMapByExample(t);
	}
	
	/**
	 * 	根据条件构造查询
	 *
	 * @param wapper 条件构造器
	 * @return 对象列表
	 */
	@Override
	public List<T> findListByConditions(QueryWrapper wrapper) {
		return dao.queryListByConditions(wrapper);
	}
	
	/**
	 * 	根据条件构造查询
	 *
	 * @param wapper 条件构造器
	 * @return 对象列表
	 */
	@Override
	public List<Map<String, Object>> findListMapByConditions(QueryWrapper wrapper) {
		return dao.queryListMapByConditions(wrapper);
	}
	
	/**
	 * 	根据对象和条件构造查询
	 *
	 * @param t 查询条件
	 * @param wapper 条件构造器
	 * @return 对象列表
	 */
	@Override
	public List<T> findListByConditions(T t,QueryWrapper wrapper) {
		return dao.queryListByConditions(t, wrapper);
	}
	
	/**
	 * 	根据对象和条件构造查询
	 *
	 * @param t 查询条件
	 * @param wapper 条件构造器
	 * @return 对象列表
	 */
	@Override
	public List<Map<String, Object>> findListMapByConditions(T t,QueryWrapper wrapper) {
		return dao.queryListMapByConditions(t, wrapper);
	}
	
	/**
	 * 	根据对象分页查询（默认当前页：1，每页条数：10）
	 *
	 * @return 分页对象PageInfoBean<Bean>
	 */
	@Override
	public PageInfoBean page(int curPage,int perPage) {
		return dao.page(curPage, perPage);
	}
	
	/**
	 * 	根据对象分页查询（默认当前页：1，每页条数：10）
	 *
	 * @return 分页对象PageInfoBean<Map>
	 */
	@Override
	public PageInfoBean pageMap(int curPage,int perPage) {
		return dao.pageMap(curPage, perPage);
	}
	
	/**
	 * 	根据对象分页查询（默认当前页：1，每页条数：10）
	 *
	 * @param t 查询条件
	 * @return 分页对象PageInfoBean<Bean>
	 */
	@Override
	public PageInfoBean pageByExample(T t,PageInfoBean page) {
		return dao.pageByExample(t, page);
	}
	
	/** 
	 * 	根据对象分页查询（默认当前页：1，每页条数：10）
	 *
	 * @param t 查询条件
	 * @return 分页对象PageInfoBean<Map>
	 */
	@Override
	public PageInfoBean pageMapByExample(T t,PageInfoBean page) {
		return dao.pageMapByExample(t, page);
	}

	/**
	 * 	通用根据主键物理批量删除
	 *
	 * @param keys 主键列表
	 * @return 影响行数
	 */
	@Override
	public int delByIds(Object... keys) {
		return dao.delete(keys);
	}

	/**
	 * 	通用根据主键逻辑删除，列需要添加 {@link Logic} 注解
	 *
	 * @param keys 主键列表
	 * @return 影响行数
	 */
	@Override
	public int remoByIds(Object... keys) {
		return dao.remove(keys);
	}

	/**
	 * 	通用特殊条件逻辑删除
	 *
	 * @param wrapper 条件构造器
	 * @return 影响行数
	 */
	@Override
	public int remoByConditions(QueryWrapper wrapper) {
		return dao.removeByConditions(wrapper);
	}

	/**
	 * 	通用根据主键数组查询记录
	 *
	 * @param primarykey 主键
	 * @return 单条记录
	 */
	@Override
	public List<T> findListByIds(Object... primarykey) {
		return dao.queryListByIds(primarykey);
	}
	
	/**
	 * 	通用根据主键数组查询记录
	 *
	 * @param primarykey 主键
	 * @return 单条记录
	 */
	@Override
	public List<Map<String, Object>> findListMapByIds(Object... primarykey) {
		return dao.queryListMapByIds(primarykey);
	}

	/**
	 * 	根据对象和条件分页查询（默认当前页：1，每页条数：10）
	 *
	 * @param t 查询条件
	 * @return 分页对象PageInfoBean<Bean>
	 */
	@Override
	public PageInfoBean pageByConditions(QueryWrapper wrapper, PageInfoBean page) {
		return dao.pageByConditions(wrapper, page);
	}

	/**
	 * 	根据对象和条件分页查询（默认当前页：1，每页条数：10）
	 *
	 * @param t 查询条件
	 * @return 分页对象PageInfoBean<Bean>
	 */
	@Override
	public PageInfoBean pageMapByConditions(QueryWrapper wrapper, PageInfoBean page) {
		return dao.pageMapByConditions(wrapper, page);
	}

	/**
	 * 	通用根据主键更新，自增列需要添加 {@link Primarykey} 注解
	 *
	 * @param t  对象
	 * @param fieldList 更新条件(T中的作为条件的字段名列表)并忽略其中的 null值
	 * @return 操作的行数
	 */
	@Override
	public int saveByExample(T t, String... fieldArrays) {
		return dao.updateByExample(t, fieldArrays);
	}

	/**
	 * 	通用根据主键更新，自增列需要添加 {@link Primarykey} 注解
	 *
	 * @param t  对象
	 * @param fieldList 更新条件(T中的作为条件的字段名列表)并忽略其中的 null值
	 * @return 操作的行数
	 */
	@Override
	public int saveByExample(T t, List<String> fieldList) {
		return dao.updateByExample(t, fieldList);
	}

	/**
	 * 	通用根据主键查询单条记录 （联合主键，未测试）
	 *
	 * @param primarykey 主键
	 * @return 单条记录
	 */
	@Override
	public Map<String, Object> findMapByUniteId(Object... primarykey) {
		return dao.queryMapByUniteId(primarykey);
	}

	/**
	 * 	根据对象和条件分页查询（默认当前页：1，每页条数：10）
	 *
	 * @param t 查询条件
	 * @param wapper 条件构造器
	 * @return 分页对象PageInfoBean<Bean>
	 */
	@Override
	public PageInfoBean pageByConditions(T t, QueryWrapper wrapper, PageInfoBean page) {
		return dao.pageByConditions(t, wrapper, page);
	}
	
	/**
	 * 	根据对象和条件分页查询（默认当前页：1，每页条数：10）
	 *
	 * @param t 查询条件
	 * @param wapper 条件构造器
	 * @return 分页对象PageInfoBean<Bean>
	 */
	@Override
	public PageInfoBean pageMapByConditions(T t, QueryWrapper wrapper, PageInfoBean page) {
		return dao.pageMapByConditions(t, wrapper, page);
	}

	/**
	 * 	通用根据主键更新，自增列需要添加 {@link Primarykey} 注解
	 *
	 * @param t  对象
	 * @param fieldList 更新条件(T中的作为条件的字段名列表)
	 * @param ignore 是否忽略 null 值
	 * @return 操作的行数
	 */
	@Override
	public int saveByExample(T t, Boolean ignore, String... fieldArrays) {
		return dao.updateByExample(t, ignore, fieldArrays);
	}

	/**
	 * 	通用特殊条件修改
	 *
	 * @param wrapper 修改条件构造器
	 * @return 影响行数
	 */
	@Override
	public int saveByConditions(UpdateWrapper wrapper) {
		return dao.updateByConditions(wrapper);
	}

	/**
	 * 	根据对象查询
	 *
	 * @param t 查询条件，若查询结果为多个则取第一条
	 * @return 对象列表
	 */
	@Override
	public T findByExample(T t) {
		return dao.queryByExample(t);
	}

	/**
	 * 	根据对象查询
	 *
	 * @param t 查询条件，若查询结果为多个则取第一条
	 * @return 对象列表
	 */
	@Override
	public Map<String, Object> findMapByExample(T t) {
		return dao.queryMapByExample(t);
	}

	/**
	 * 	根据条件构造查询
	 *
	 * @param wapper 条件构造器
	 * @return 对象列表
	 */
	@Override
	public T findByConditions(QueryWrapper wrapper) {
		return dao.queryByConditions(wrapper);
	}

	/**
	 * 	根据条件构造查询
	 *
	 * @param wapper 条件构造器
	 * @return 对象列表
	 */
	@Override
	public Map<String, Object> findMapByConditions(QueryWrapper wrapper) {
		return dao.queryMapByConditions(wrapper);
	}
	
	/**
	 * 	根据条件构造查询
	 *
	 * @param wapper 条件构造器
	 * @return 总条数
	 */
	@Override
	public Integer findCount(QueryWrapper wrapper) {
		return dao.queryCount(wrapper);
	}
}
